<!DOCTYPE html>


<html lang="zh-Hans">
  

    <head>
      <meta charset="utf-8" />
       
      <meta name="keywords" content="博客，代码，思考，生活" />
       
      <meta name="description" content="笔记汇总" />
      
      <meta
        name="viewport"
        content="width=device-width, initial-scale=1, maximum-scale=1"
      />
      <title>初学java |  Zhang Shuo&#39;s Studio</title>
  <meta name="generator" content="hexo-theme-ayer">
      
      <link rel="shortcut icon" href="/hexo1/favicon.ico" />
       
<link rel="stylesheet" href="/hexo1/dist/main.css">

      <link
        rel="stylesheet"
        href="https://cdn.jsdelivr.net/gh/Shen-Yu/cdn/css/remixicon.min.css"
      />
      
<link rel="stylesheet" href="/hexo1/css/custom.css">
 
      <script src="https://cdn.jsdelivr.net/npm/pace-js@1.0.2/pace.min.js"></script>
       
 

      <link
        rel="stylesheet"
        href="https://cdn.jsdelivr.net/npm/@sweetalert2/theme-bulma@5.0.1/bulma.min.css"
      />
      <script src="https://cdn.jsdelivr.net/npm/sweetalert2@11.0.19/dist/sweetalert2.min.js"></script>

      <!-- mermaid -->
      
      <style>
        .swal2-styled.swal2-confirm {
          font-size: 1.6rem;
        }
      </style>
    <link rel="alternate" href="/hexo1/atom.xml" title="Zhang Shuo's Studio" type="application/atom+xml">
</head>
  </html>
</html>


<body>
  <div id="app">
    
      
    <main class="content on">
      <section class="outer">
  <article
  id="post-java基础/笔记1"
  class="article article-type-post"
  itemscope
  itemprop="blogPost"
  data-scroll-reveal
>
  <div class="article-inner">
    
    <header class="article-header">
       
<h1 class="article-title sea-center" style="border-left:0" itemprop="name">
  初学java
</h1>
 

      
    </header>
     
    <div class="article-meta">
      <a href="/hexo1/2019/08/13/java%E5%9F%BA%E7%A1%80/%E7%AC%94%E8%AE%B01/" class="article-date">
  <time datetime="2019-08-13T09:00:00.000Z" itemprop="datePublished">2019-08-13</time>
</a> 
  <div class="article-category">
    <a class="article-category-link" href="/hexo1/categories/java%E5%9F%BA%E7%A1%80/">java基础</a>
  </div>
  
<div class="word_count">
    <span class="post-time">
        <span class="post-meta-item-icon">
            <i class="ri-quill-pen-line"></i>
            <span class="post-meta-item-text"> Word count:</span>
            <span class="post-count">14.6k</span>
        </span>
    </span>

    <span class="post-time">
        &nbsp; | &nbsp;
        <span class="post-meta-item-icon">
            <i class="ri-book-open-line"></i>
            <span class="post-meta-item-text"> Reading time≈</span>
            <span class="post-count">57 min</span>
        </span>
    </span>
</div>
 
    </div>
      



  
    <div class="article-entry" itemprop="articleBody">
       
  <blockquote>
<p><strong>第一部分</strong></p>
</blockquote>
<p>计算机处理数据的最小单位是1个字节，1个字节等于8位</p>
<p><strong>（1）boolen：</strong></p>
<p><strong>boolean到底占几个字节，依赖于JVM</strong></p>
<p><strong>第一，无论Boolean占用多少字节，只有1bit的值是有意义的</strong></p>
<p><strong>第二，boolean 类型被编译成 int 类型来使用，占 4 个 byte 。</strong></p>
<p><strong>第三，在 Java 虚拟机里，1 表示 true ，0 表示 false 。</strong></p>
<p>（2）整数：</p>
<p>byte：1个字节，表示有符号，以二进制补码表示的整数；</p>
<p>short：2个字节；</p>
<p><strong>int：4个字节；</strong></p>
<p>long：8个字节；</p>
<p>（3）float：4个字节； double：8个字节；</p>
<p><strong>（4）char：2个字节；</strong></p>
<p>char 类型是一个单一的 16 位 Unicode 字符；</p>
<p>最小值是 \u0000（十进制等效值为 0）；</p>
<p>最大值是 \uffff（即为 65535）；</p>
<p>Byte，Short，Integer这种是包装类，不是数据类型。</p>
<p>string不是基本数据类型，基本数据类型有八种。</p>
<p>boolean默认为false；</p>
<p>浮点数转为int类型，舍弃全部小数部分而不是四舍五入。</p>
<p>基本数据类型转换(string除外)，要么强制转换，要么自动类型转换</p>
<p>类型转换只关注数据类型的长度！在把容量大的类型转换为容量小的类型时必须使用强制类型转换。小长度数据类型转大长度，直接写等号即可。</p>
<p>小长度数据A=(A的数据类型)大长度数据 大长度数据A=小长度数据</p>
<p>Unicode字符是什么？16进制的Unicode字符。</p>
<p>小数默认为double，float类型数据后必须加上f/F，但double不需要加。整数默认为int</p>
<p>1. long a = 3l //long类型赋值需要在后面加上字母l</p>
<p>2. float a = 1.22f //float类型赋值需要在后面加上f</p>
<p>3. boolean a = true //布尔类型赋值不是bool，而是boolean, true小写（Python是第一个大写）</p>
<p>5. char类型的变量和除string外所有类型变量相加，第一步永远是先把char类型变量转为ASCII码，之后再和其他的相加，</p>
<p><strong>字符与字符相加得到 int</strong></p>
<p>6. 如何<strong>获取变量的类型</strong>？</p>
<p>public static String getType(Object o){ return o.getClass().toString(); //得到的是包装类 }</p>
<p>6. System.out.println(getType(&#39;a&#39;+&#39;b&#39;)); //在上述代码的基础上结果是 classjava.lang.Integer，也就是 int类型</p>
<p>7. char c=1+&#39;a&#39; //得到的还是字符(前面定义了是char)</p>
<p>6. 字符串无论和什么相加得到的都是字符串类型</p>
<p>错误：System.out.println(byte(1000000)); python是b=int(a)；</p>
<p>11. Java：<strong>4/3=1；</strong>Python：4/3=1.333333 4//3=1</p>
<p>12. &amp;与&amp;&amp;的区别：</p>
<p>a=1;False&amp;&amp;(++a!=2)：运算符左边为False，则右边不参与运算,所以a仍然还是1</p>
<p>|| 同样如此，左边为True，右边不参与运算</p>
<p>13. ~是反码，~6=-7 在底层运算中，必须以字节为单位，6参与运算那必须是00000110参与运算</p>
<p>16. 只有负数右移是补1，其他全部都补0</p>
<p>17. 无符号数左右移，高位都补0</p>
<p>18. ~</p>
<p>19. 注意switch怎么用的：</p>
<p><img src="media/image1.png" alt="clipboard.png">{width=”3.5694444444444446in” height=”2.64574365704287in”}</p>
<p><strong>第二部分</strong></p>
<p>1. <strong>String[] strs = new String[ ]{&quot;a&quot;,&quot;b&quot;,&quot;c&quot;}</strong></p>
<p>String[] strings2 = new String [ 2 ] {&quot;1&quot;，&quot;2&quot;} ; //错误，指定内容则不能加上范围</p>
<p>String[] strings2 = new String [ ] {1，2} ; //错误</p>
<p>String[] strings2 = new String () [ ] {&quot;1&quot;, &quot;2&quot;} ; //错误</p>
<p>2. int[] a = new int[2] 有且默认值是0</p>
<p>3. 数组不是方形的，只是一维数组的每个元素都是数组而已，矩阵不一定是长方形</p>
<p>4. 注释方法：// 或者 /**再按回车键 python是#</p>
<p>5. 方法名称有多个单词，则<strong>第一个单词首字母小写，其他首字母大写(属性也是)</strong></p>
<p>6. 类Person内定义了public String name;(public可以不写)，外部调用方法：</p>
<p>即使不在一个.java内，但只要在一个包内就可以直接Person person1=new Person()</p>
<p>7. 类变量：public static String sex=&quot;男&quot;;外部要用到这个属性</p>
<p>直接Person.sex就可以使用了，不需要再Person person2=new Person(),</p>
<p>8. 形参：在class Person内public void eat(String food){}food就是形参</p>
<p>9. 方法局部变量:在类的方法体中定义了个int a;就是局部变量</p>
<p>10. 代码块局部变量:</p>
<p>11. 成员变量：(1) 定义在类中，在整个类中都可以被访问</p>
<p>(2)成员变量分为类成员变量和实例成员变量，实例变量存在于对象所在堆内存中</p>
<p>(3)成员变量有默认初始化值</p>
<p>(4)成员变量的权限修饰符可以根据需要任意选择一个公有私有</p>
<p>12. <strong>static方法内不能访问非static的成员变量</strong>，编译不通过</p>
<p>例如class内，在public static void main(String[] args){}的外部定义了int a;</p>
<p>那么main内就不能调用a; 注意是在同一个class内部，并没有另外定义一个实例对象</p>
<p>13. <strong>形参</strong>：方法声明时的参数，比如public void printInfo(String[] args)括号内的args</p>
<p>14. <strong>实参</strong>：方法调用时实际传给形参的参数值，比如person.printInfo(argss);括号内的args</p>
<p>13. <strong>可变参数</strong>：</p>
<p>public class Person {</p>
<p>1.不要加static</p>
<p>2.用数组的方式来传递可变个数的参数</p>
<p>3.必须填入参数，括号内是可以使null或者定义一个空数组再填入参数</p>
<p>public void printInfo(String[] args) { for(int i=0; i&lt;args.length; i++) { System.out.println(args[i]); } }</p>
<p>获取长度直接.length()即可，例如：&quot;dnqoedno&quot;.length()</p>
<p>* <strong>1.用java特有的...的方式来传递可变个数的参数，这种参数在使用时数组的使用方式相同</strong></p>
<p>* 2.如果没有参数就可以不填</p>
<p>* 3.这种...代表可以传递0到多个参数</p>
<p>* 4.如果一个方法有多个的形参，可变的形参（...这种的参数）一定要放在所有的参数最后</p>
<p>printInfo1(String s, int b, String...args) 这样的参数放置顺序是对的 printInfo1(String s, String...args, int d) 这样的参数放置顺序是不对的 printInfo1(String...args, String s, int d) 这样的参数放置顺序是不对的 public void printInfo1(String... args) { for(int i=0; i&lt;args.length; i++) { System.out.println(args[i]); } } }</p>
<p>另建个.java文件</p>
<p>public class test1 { public static void main(String[] args) { Person person = new Person(); String[] argss = new String[] {&quot;1&quot;,&quot;1&quot;,&quot;2&quot;,&quot;3&quot;,&quot;4&quot;,&quot;5&quot;}; person.printInfo(argss); String[] argss = new String[] {&quot;北京市xxx&quot;,&quot;1310131&quot;,&quot;dqdqd&quot;}; person.printInfo1(argss); person.printInfo1(&quot;1&quot;,&quot;2&quot;,&quot;3&quot;,&quot;4&quot;,&quot;5&quot;); } }</p>
<p><strong>1. 特有的...形式不写参数也不会报错</strong></p>
<p><strong>2. 而用数组的方式不写参数会报错</strong>，必须传入数组即使为空或null</p>
<p>person.printInfo1(); // 空数组 person.printInfo(); // 会报错 person.printInfo(null); String[] argss1 = new String[0]; //定义空数组 person.printInfo(argss1);</p>
<p>说明：</p>
<p>1.可变参数：方法参数部分指定类型的参数个数是可变多个</p>
<p>3.可变参数方法的使用与方法参数部分使用数组是一致的</p>
<p>4.<strong>方法的参数部分有可变形参，需要放在形参声明的最后</strong></p>
<p><strong>14. JVM的内存模型, 栈stack，堆heap，方法区method</strong></p>
<p>int i = 1; //i指向栈地址A，A地址的值为1，数据就存储在栈中</p>
<p><strong>Person p=new Person()：//P指向栈地址A，A内存储着堆heap的地址B，B内存储着new Person对象</strong></p>
<p>栈：基础数据类型(具体值)和对象的引用(地址)</p>
<p>堆：所有的对象(包括自己定义的对象和字符串对象)</p>
<p>方法区：所有的class和static变量</p>
<p>15. 方法的参数传递</p>
<ol>
<li><p>如果方法的形参是基本数据类型，那么实参（实际的数据）向形参传递参数时直接传递值，把实参的值赋值给形参</p>
</li>
<li><p>如果方法的形参时对象，那么实参（实际的对象）向形参传递参数时，也是把值给形参，这个值是实参在栈内存中的值，也就是引用对象在堆内存中的地址</p>
</li>
<li><p>基本数据类型都是保存在栈内存中，引用对象在栈内存中保存的是引用对象的地址，那么方法的参数传递是传递值（是变量在栈内存当中的值）</p>
</li>
</ol>
<p><strong>第三部分</strong></p>
<p>1. 包用小写单词，类名首字母大写，用”.”指明包的层次，比如animal.cat</p>
<p>2. 引用别的包里面的Person类：import day.test.Person; 或者import day.test.*; 或者day.test.Person p=new day.test.Person();</p>
<p><strong>静态导包：</strong>import static 包路径.类.变量名</p>
<p>3. 引用所在包内的其他类，不用写import</p>
<p>4. 信息的<strong>封装</strong>和隐藏：把数据声明为私有的，再提供公有的方法setAge(注意第一个单词首字母小写，之后单词首字母大写)实现对改属性的操作。从而方便的加入控制逻辑限制对属性的不合理操作，便于修改，增强代码的可维护性。</p>
<blockquote>
<p>隐藏：Person类的属性age设为private int age;</p>
<p>封装：Person类内设置方法</p>
</blockquote>
<p><strong>什么是封装？</strong></p>
<p>把该隐藏的隐藏起来，把该暴露的暴露出来。四种访问控制符来进行控制</p>
<p>选中所有属性后，鼠标右键找到source -&gt; Generate Getters and Setters</p>
<p>5. 修饰符有：private,缺省(即没有修饰符)，public，protected</p>
<p>缺省定义的属性a，只能在同一个包内对其访问（假设a在包day的类person内,day的子包day.demo中的类不能对其访问）</p>
<p>Yes为可以访问该属性，没有Yes即不能访</p>
<p><strong>private： 类内部（Yes） 同一个包（ ） 子类（ ） 任何地方（ ）</strong></p>
<p><strong>缺省： 类内部（Yes） 同一个包（Yes） 子类（ ） 任何地方（ ）</strong></p>
<p><strong>protected：类内部（Yes） 同一个包（Yes） 子类（Yes） 任何地方（ ）</strong></p>
<p><strong>public： 类内部（Yes） 同一个包（Yes） 子类（Yes） 任何地方（Yes）</strong></p>
<p><strong>在类内直接写int a;这就是缺省。protected int b;</strong></p>
<p>6. 创建类public class Person的时候默认创建了构造方法public Person(){};前提是没自己创构造器</p>
<p>Person p=new Person();就是调用了Person()方法</p>
<p>类是缺省的，构造方法就也是缺省的，以此类推</p>
<p>7. 1. 可以自己设置构造方法：</p>
<p>public class Person{ public Person(){ age=1; name=&quot;张三&quot;; } public int age; public String name; public showInfo(){ System.out.println(age); System.out.println(name); } }</p>
<p>随后：</p>
<p>Person p=new Person(); p.showInfo();</p>
<ol start="2">
<li>可以设置带参数的构造方法：</li>
</ol>
<p>public Person(int a,String name_1){ age=a; name=name_1; }</p>
<ol start="3">
<li><strong>构造器本质就是初始化属性，同样还可以封装，设置个setAge方法</strong></li>
</ol>
<p><strong>8. 构造器重载：</strong></p>
<p>public class Person{ public Person(){ } public Person(int a){ age=a; } public Person(int a, String s){ age=a; name=s; } public Person(){ age=1; name=&quot;张三&quot;; } public int age; public String name; }</p>
<p>9. <strong>使用this，调用属性、方法</strong>：</p>
<p>(1) 形参与成员变量重名，需要用this，可以 增强程序阅读性</p>
<p>(2) 使用this()必须放在构造器的首行，this()就相当于Person()</p>
<p>(3) <strong>使用this调用本类中其他的构造器，保证至少有一个构造器是不用this的，实际上就是不能出现构造器自己调用自己</strong>。</p>
<p>例如：下述几个错误典型</p>
<p>class Person{ public Person(){ this(); // 错误，相当于Person()，自己调用自己 this(1); // 错误，相当于Person(1), 而Person(1)调用了this()， // 仍是自己调用自己 this(&quot;张三&quot;) //正确，相当于Person(&quot;张三&quot;) } public Person(int age){ this(); // 等同于调用public Person() this.age = age; } public Person(String name){ this.name = name; } public Person(String name, int age){ this(1); //等同于调用public Person(int age) this.name = name; this.age = age; } private String name; private int age; public void getInfo(){ System.out.prinln(this.name); this.speak(); } public void speak(){ System.out.prinln(this.age); } }</p>
<p>10.（1）JavaBean：<strong>Java语言写成的可重用组件</strong></p>
<p>（2）所谓javaBean是指符合如下标准的Java类：</p>
<p><strong>类是公共的</strong></p>
<p><strong>有一个无参的公共的构造器</strong></p>
<p><strong>有属性，属性一般是私有的，且有对应的get、set方法</strong></p>
<ol start="3">
<li>public class Person{</li>
</ol>
<p>private String name;</p>
<p>private int sex;</p>
<p>private int age;</p>
<p>}</p>
<p>编写完private属性后，先选中包含private属性的几行代码，再鼠标右键Source -&gt; Generate Getters and Setters...</p>
<p><strong>第四部分</strong></p>
<p>1. 类的继承：子类不是父类的子集，而是父类的扩展</p>
<p>publicn class Student extends Person{}</p>
<p>2. Java只支持单继承，不允许多重继承，这点和python不同</p>
<p>3. 快速注释代码：Crtl + 左边的/（按右边的/无效）</p>
<p><strong>快速重写方法：Alt + /</strong></p>
<p>5. 方法的重写：</p>
<ol>
<li><p>重写方法必须和被重写方法具有相同的方法名称，参数列表和返回值类型</p>
</li>
<li><p>重写方法不能使用比被重写方法更严格的访问权限</p>
</li>
<li><p>重写和被重写的方法须同时为static的，或同时为非static</p>
</li>
<li><p>子类方法抛出的异常不能大于父类被重写方法的异常</p>
</li>
</ol>
<p>6. 分清<strong>方法重载&amp;重写</strong>的概念。前者是指一个类可以有多个同名方法，后者是子类可以重写父类的方法，覆盖父类方法</p>
<p>7. super：</p>
<p>使用super，子类可以调用之上所有的父类层次</p>
<p>super和this的用法很像，this代表本类对象的引用，super代表父类的内存空间的标识</p>
<p>8. (1) 子类中所有的构造器默认都会访问父类中空参数的构造器</p>
<p>(2) <strong>当父类中没有空参数的构造器时，子类的构造器必须通过this(参数列表)或者super(参数列表)语句指定调用本类或者父类中相应的构造器，且必须放在构造器的第一行</strong></p>
<p>(3) <strong>如果子类构造器中既未显示调用父类或本类的构造器，且父类中又没有无参的构造器，则编译出错。</strong></p>
<p><strong>所以说写构造器时一定要写个无参的构造器</strong></p>
<p>例如：父类ManKid中有一个public ManKid(int sex, int salary){...}并且只有这一个构造函数</p>
<p>则：子类Kids必须有个</p>
<p>public Kids(int sex, int salary){ super(sex, salary); //只能放在第一行 int i =1; }</p>
<p><strong>9. super和this的区别：以下四点都必须记清</strong></p>
<p>(1). 访问属性 : this访问本类中的属性，如果本类没有此属性则从父类中继续查找，super只能访问父类的属性，父类不包括父类的父类</p>
<p>(2). 调用方法：this访问本类中的方法不能访问父类的方法，super直接访问父类中的方法</p>
<p>(3). 调用构造器：this访问本类中的方法，super调用父类构造器，必须放在子类构造器的首行</p>
<p>(4). 特殊：this表示当前对象，super无此概念。</p>
<p><strong>第五部分</strong></p>
<p>一、简单类对象的实例化过程：</p>
<p>public class Person{</p>
<p>public Person(){}</p>
<p>int age =1; // 以缺省修饰</p>
<p>String name = &quot;zs&quot;;</p>
<p>int sex = 0;</p>
<p>....….</p>
<p>}</p>
<p>1. 先在方法区加载Person.class 2. 在栈中申请空间，声明变量P 3. （1）在堆内存中开辟空间，分配地址，假设地址为.… （2）在对象空间中，对对象中的属性进行默认初始化，此时age=0,sex=0,name=null （3）类成员变量显示初始化，此时age=1,name=&quot;zs&quot;,sex=0 3. 构造函数方法进栈，进行初始化。 4. 初始化完毕后，将堆内存中的地址赋值给引用变量，构造方法出栈。 5. 第二步内容出栈。</p>
<p>二、子类对象的实例化过程：</p>
<p>public class Person{ public Person(){} int age =1; String name = &quot;zs&quot;; int sex = 0; } public class Student extends Person{ public Student(){ super(); } String school = &quot;11&quot;; } Student stu = new Student();</p>
<p>1. 方法区先加载父类Person.class，后加载子类Student.class 2. 栈中申请空间，声明变量stu 3. 在栈内存中开辟空间，分配地址，也就是new Student() 4. 在对象空间中，对对象中的所有属性(包括父类的属性）进行默认初始化 5. 子类构造函数方法进栈 6. 显示初始化父类的属性 7. 父类构造方法进栈，执行完毕出栈 8. 显示初始化子类的属性 9. 初始化完毕后，将堆内存中的地址值赋给引用变量，子类构造方法出栈</p>
<p><strong>三：多态</strong></p>
<ol>
<li><strong>多态性是对象多种表现形式的体现</strong>，现实中，比如我们按下 F1 键这个动作：</li>
</ol>
<p>如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；</p>
<p>如果当前在 Word 下弹出的就是 Word 帮助；</p>
<p>在 Windows 下弹出的就是 Windows 帮助和支持。</p>
<p>同一个事件发生在不同的对象上会产生不同的结果。</p>
<ol start="2">
<li><p>多态的优点</p>
</li>
<li><p>消除类型之间的耦合关系</p>
</li>
<li><p>可替换性</p>
</li>
<li><p>可扩充性</p>
</li>
<li><p>接口性</p>
</li>
<li><p>灵活性</p>
</li>
<li><p>简化性</p>
</li>
<li><p><strong>多态存在的三个必要条件</strong></p>
</li>
</ol>
<p>继承</p>
<p>重写</p>
<p>父类引用指向子类对象</p>
<ol start="4">
<li>多态使用的好处：</li>
</ol>
<p><strong>消除了类之间的耦合关系</strong></p>
<p>大大提高了程序的简洁性和可拓展性</p>
<ol start="5">
<li><strong>多态的实现方式</strong></li>
</ol>
<p><strong>方式一：重写：</strong></p>
<p>这个内容已经在上一章节详细讲过，就不再阐述，详细可访问：Java 重写(Override)与重载(Overload)</p>
<p><strong>方式二：接口：</strong></p>
<ol>
<li><p>生活中的接口最具代表性的就是插座，例如一个三接头的插头都能接在三孔插座中，因为这个是每个国家都有各自规定的接口规则，有可能到国外就不行，那是因为国外自己定义的接口类型。</p>
</li>
<li><p>java中的接口类似于生活中的接口，就是一些方法特征的集合，但没有方法的实现。具体可以看 java接口 这一章节的内容。</p>
</li>
</ol>
<p><strong>方式三：抽象类和抽象方法</strong></p>
<p>public class Person { int id=101; public void eat(){ System.out.println(&quot;人吃饭&quot;);} public void drink(){ System.out.println(&quot;人喝水&quot;);} } class Man extends Person{ int id=102; public void eat(){ System.out.println(&quot;男人吃饭&quot;);} public void drink(){ System.out.println(&quot;男人喝水&quot;);} public void smoking(){ System.out.println(&quot;男人抽烟&quot;);} } class Woman extends Person{ int id=103； public void eat(){System.out.println(&quot;女人吃饭&quot;);} public void drink(){System.out.println(&quot;女人喝水&quot;);} public void shoping(){System.out.println(&quot;女人购物&quot;);} } public class Test1 { public static void main(String[] args) { Test1 test=new Test1(); test.show(new Person());//等同于Person p=new Person() test.show(new Man()); //等同于Person p=new Man() test.show(new Women()); //等同于Person p=new Women() } public void show(Person p){ p.eat(); p.drink(); System.out.println(p.id) } } 输出： 人吃饭 人喝水 101 男人吃饭 男人喝水 101 女人吃饭 女人喝水 101 ******* 为什么输出的id都一样？？ *********</p>
<p><strong>切记：Person p=new Man();</strong></p>
<p><strong>p.id 是Person.id, 不是Man.id</strong></p>
<p><strong>p.eat() 是Man.eat(), 不是Person.eat()</strong></p>
<p><strong>1. 子类对象的多态性，并不适用于属性</strong></p>
<p><strong>2. 子类多态性的使用，是使用父类的引用，指向子类的对象，然后虚拟方法调用子类重写父类的方法</strong></p>
<p><strong>3. 如果上面main方法中，test.show(new Man()); 和test.show(new Woman());</strong></p>
<p><strong>调用show()方法只能传Person对象的实例，不能使用子类对象的多态性，那么想实现show()方法传入Man和Woman的对象 都调用方法的话，得再另外写两个各自的show()方法，这样代码冗余不简洁</strong></p>
<p>Person p=new Man()如果不能使用多态的话，那么想实现show()方法传入Man和Woman的对象，在调用方法的话，得再写另外写两个各自的show()方法</p>
<p>对象<strong>a instanceof 类A</strong> 判断对象a是否是类A的一个实例是的话返回true，否的话返回false</p>
<p><strong>以下很重要：</strong></p>
<p>没有向上转型</p>
<p>public class Test { public static void main(String[] args) { Test test=new Test(); test.show(new Person()); test.show(new Man()); test.show(new Woman()); } public void show(Person p){ p.eat(); p.drink(); if(p instanceof Man){ Man man=(Man)p;//向下转型，使用强转符 man.smoking(); System.out.println(man.id); } if(p instanceof Woman){ Woman woman=(Woman) p;//向下转型，使用强转符 woman.shoping(); System.out.println(woman.id); } } } // 这样既可以正确输出各自的id了</p>
<p><strong>四、instanceof</strong></p>
<ol>
<li>x instanceof A只能用于检验x是否是类A的对象</li>
</ol>
<p><strong>不是检验 x属于类型A</strong></p>
<p>Student s=new Student(); Person p=new Person(); Person p1=new Student(); System.out.println(s instanceof Student); //True System.out.println(s instanceof Person); //True System.out.println(p instanceof Student); //False System.out.println(p1 instanceof Student);//True System.out.println(p1 instanceof Person); //True</p>
<p>五、Object：</p>
<ol>
<li><p>在类的声明中未使用extends关键字指明其父类，则默认父类为Object类</p>
</li>
<li><p>例如想给方法设置个形参参数，这个参数我不确定到底会传进来一个什么类，但可以确定的是传递实参一定会是一个类，那么test方法的形参要设置一个什么类型？</p>
</li>
</ol>
<p>public class Test{</p>
<p>public void test(Object obj){}</p>
<p>}</p>
<ol start="3">
<li>Object 类中的主要方法：</li>
</ol>
<p>public Object{}构造函数 public boolean equals(Object obj)对象比较 public int hashCode{}获得Hash码 public String toString{}对象打印时调用</p>
<p>六、对象类型转化：</p>
<ol>
<li>小的数据类型可以自动转换成大的数据类型，子类就是小的数据类型</li>
</ol>
<p>切记：父类到子类需强制类型转换，Person p=new Person(){}</p>
<p><strong>第六部分</strong></p>
<p>一、操作系统如何执行String对象的创建：</p>
<ol>
<li>String s1=&quot;abc&quot;;</li>
</ol>
<p>String s2=&quot;abc&quot;;</p>
<p><strong>执行第一句，堆中有字符串常量池，若判断常量池中无&quot;abc&quot;字符串，则添加&quot;abc&quot;对象，并返回引用地址给s1对象</strong></p>
<p><strong>执行第二句，通过equals()方法判断常量池中已有值为&quot;abc&quot;的对象，直接返回相同的引用</strong></p>
<p>2. String s3=new String(&quot;abc&quot;);</p>
<p>String s4=new String(&quot;abc&quot;);</p>
<p><strong>执行第一句，若判断常量池中无&quot;abc&quot;，则在常量池中添加&quot;abc&quot;对象，再在堆中(常量池外)新建名为&quot;abc&quot;的对象s3，并返回指向堆中s3的引用</strong></p>
<p><strong>执行第二句，若判断常量池中有&quot;abc&quot;，则在堆中(常量池外)新建个名为&quot;abc&quot;的对象s4，并返回指向堆中s4的引用</strong></p>
<p>3. String s5=&quot;a&quot;+&quot;b&quot;;</p>
<p><strong>执行该语句，经过JVM的优化，先得到&quot;a&quot;+&quot;b&quot;的结果，再直接在常量池中添加&quot;ab&quot;对象</strong></p>
<p>4. String s6=new String(&quot;a&quot;)+new String(&quot;a&quot;)+new String(&quot;b&quot;);</p>
<p><strong>执行该语句，通过StringBuilder实现，在常量池中添加&quot;a&quot;和&quot;b&quot;两个对象，再在堆中创建值为&quot;aab&quot;的对象，把引用地址给s6,注意常量池中有两个对象，堆中(池外)只有一个名为&quot;aab&quot;的对象</strong></p>
<p>二、</p>
<p><strong>总结：</strong></p>
<p><strong>比较字符串用 equals()</strong></p>
<p><strong>字符串除外的基本类型用 “==”</strong></p>
<ol>
<li>&quot;==&quot;</li>
</ol>
<p>(1). 当比较的变量是基本类型，且都是数值类型，且’==&#39;比较的是其数值。</p>
<p>(2). 当比较的是引用变量，只有当他们都指向同一个对象的时候才会返回true。</p>
<p>(3). 其不可以用去在类型上比较没有继承关系的的两个变量，编译器会报错。</p>
<ol start="2">
<li>equals():</li>
</ol>
<p>(1). <strong>所有类都继承了Object，也就是获得了equals()方法，还可以重写</strong></p>
<p>(2). 只能比较引用类型，起作用与&quot;=&quot;相同，比较是否指向同一个对象。</p>
<p>(3). 格式：<strong>obj1.equals(obj2)</strong></p>
<p>(4). 特例：当用equals()方法进行比较时，对类File、String、Date及包装类(Wrapper Class)来说，是比较类型及内容而不考虑引用的是否时同一个对象；</p>
<p>原因：在这些类中重写了Object类的equals()方法</p>
<ol start="3">
<li><strong>实际上，&quot;==&quot;和equals()除特殊类外都是比较的内存地址！对于特殊类equals()比较内容(值)(equals改写了)</strong></li>
</ol>
<p><strong>以下极其重要：</strong></p>
<p>int it 65 ; float f = 65.0f System.out.println(it == f); //True char ch = &#39;A&#39;; System.out.println(ch == it); //True char ch2=12; 注意是数字12 System.out.println(ch2 == 12); //True // 当用”=”比较时，符号两边的数据类型必须兼容(可自动转换的基本数据类型除外), //否则编译会出错 Test t=new Test(); System.out.prinln(p1==t); //报错 // 对于所有对象(除基本数据类型外就是对象)，&quot;=&quot;比较的是对象的地址 // 除特殊类外，equals 和 = 相同 Person p1=new Person(); Person p2=new Person(); sout(p1==p2); //False，只有指向同一个对象时才返回True //只能比较引用类型，其作用和&quot;=&quot;相同，比较是否指向同一个对象 sout(p1.equals(p2)); // true Person p3=p1; sout(p1==p3); //True // 对于特殊的类，equals()比较的是内容，而&quot;==&quot;比较的是对象地址 String s1=new String(&quot;abc&quot;); String s2=new String(&quot;abc&quot;); sout(s1==s2); // False sout(s1.equals(s2)); //True Person p1=new Person(); p1.name=&quot;abc&quot;; //p1.name属性是字符串,不是对象 p2.name=&quot;abc&quot;; sout(p1.name==p2.name); //True sout(p1.name==&quot;abc&quot;); //True sout(p1.name.equals(p2.name)); //True</p>
<p>三、<strong>编写Order类，有(int)id和(String)name，有相应的getter()和setter()，有两个参数的构造器，重写父类的equals()方法，并判断测试类中创建的两个对象是否相等。</strong></p>
<p>public class Order { // 注意名称大小写规范， public int getId() { return id; } public void setId(int id) { this.id = id; } public String getName() { return name; } public void setName(String name) { this.name = name; } public int id; public String name; public Order(int id, String name) { this.id = id; this.name = name; } /* * 因为参数是Object类，obj无法调用id属性，所以必须强制转换属性 * (大属性父类到小属性子类需强制转换)this是Order类， * 所以obj需转换到Order类后才可以调用obj.name */ @Override public boolean equals(Object obj) { boolean flag = false; // if(obj instanceof Order) { Order obj1= (Order)obj; if(obj1.id==this.id &amp;&amp; obj1.name==this.name) { flag = true; } } return flag; } } public class test1 { public static void main(String[] args) { Order a = new Order(30, &quot;abc&quot;); Order b = new Order(40, &quot;1bc&quot;); Order c = new Order(30, &quot;abc&quot;); System.out.println(a.equals(b)); System.out.println(a.equals(c)); } }</p>
<p><strong>四、包装类</strong></p>
<ol>
<li><p>主要是用来基本数据类型与字符串直接的转化</p>
</li>
<li><p>double转为int直接a=(int)b即可，但是字符串不可以</p>
</li>
<li><p><strong>字符串转化成其他类型:</strong></p>
</li>
</ol>
<p>int i = Integer.parseInt(&quot;123&quot;); float f = Float.parseFloat(&quot;0.123&quot;); boolean b = Boolean.parseBoolean(&quot;false&quot;);</p>
<ol start="4">
<li><strong>其他类型转化成字符串类型：</strong></li>
</ol>
<p>String istr=(String)i; // 错误 String istr=String.valueOf(i); String fstr=String.valueOf(f); String bstr=String.valueOf(true);</p>
<ol start="5">
<li>toString()是Object类的方法，返回对象地址</li>
</ol>
<p><strong>第七部分</strong></p>
<p>一、static：</p>
<p><strong>以下很重要：</strong></p>
<p><strong>1、总结：</strong></p>
<p>　　如果别人问你static的作用；如果你说静态修饰 类的属性 和 类的方法 别人认为你是合格的；</p>
<p>如果是说 可以构成 静态代码块，那别人认为你还可以；</p>
<p>如果你说可以构成 静态内部类， 那别人认为你不错；</p>
<p>如果你说了静态导包，那别人认为你很OK；</p>
<p><strong>(1) static方法</strong></p>
<p>当初次加载类时，非静态属性不会被加载，只有加载对象时才会被初始化</p>
<p>当初次加载类时，静态属性被加载，当且仅当加载这一次</p>
<p>static方法一般称作静态方法，由于静态方法不依赖于任何对象就可以进行访问，</p>
<p>因此对于静态方法来说，是没有this的，因为它不依附于任何对象，既然都没有对象，就谈不上this了。</p>
<p>由于这个特性，在静态方法中不能访问类的非静态成员变量和非静态成员方法，因为非静态成员方法/变量都是必须依赖具体的对象才能够被调用。</p>
<p>　　但是要注意的是，虽然在静态方法中不能访问非静态成员方法和非静态成员变量，但是在非静态成员方法中是可以访问静态成员方法/变量的。</p>
<p>　　因此，如果说想在<strong>不创建对象的情况下调用某个方法</strong>，就可以将这个方法设置为static。我们最常见的static方法就是main方法，至于为什么main方法必须是static的，现在就很清楚了。因为程序在执行main方法的时候没有创建任何对象，因此只有通过类名来访问。</p>
<p>关于构造器是否是static方法可参考：<a target="_blank" rel="noopener" href="http://blog.csdn.net/qq_17864929/article/details/48006835">http://blog.csdn.net/qq_17864929/article/details/48006835</a></p>
<p><strong>(2) static变量 ：</strong></p>
<p>static变量也称作静态变量，静态变量和非静态变量的区别是：静态变量被所有的对象所共享，在内存中只有一个副本【存放在方法区】，</p>
<p>它当且仅当在类初次加载时会被初始化，不是对象所拥有的【加final和不加final的static变量初始化的位置不一样】</p>
<p>而非静态变量是对象所拥有的，在创建对象的时候被初始化，存在多个副本，各个对象拥有的副本互不影响。</p>
<p>final成员变量表示常量，只能被赋值一次，赋值后不能再被改变。</p>
<p>static和final一起使用，static final用来修饰成员变量和成员方法，可以理解为”全局变量”</p>
<p>　　static成员变量的初始化顺序按照定义的顺序进行初始化。</p>
<p><strong>(3) static代码块</strong></p>
<p>static关键字还有一个比较关键的作用就是 用来形成静态代码块以优化程序性能。static块可以置于类中的任何地方，类中可以有多个static块。在类初次被加载的时候，会按照static块的顺序来执行每个static块，并且<strong>只会执行一次，每次实例化对象都不再执行</strong>【根据class加载原理 每个类加载一次 使用双亲委托加载】。</p>
<p>　　初始化的顺序 静态代码块 &gt; 构造代码块 &gt; 构造函数</p>
<blockquote>
<p>public class Client {</p>
<p>{//构造代码块</p>
<p>System.out.println(&quot;执行构造代码块&quot;);</p>
<p>}</p>
<p>}</p>
</blockquote>
<p>为什么<strong>说static块可以用来优化程序性能</strong>，是因为它的特性:只会在类加载的时候执行一次。下面看个例子:</p>
<p>class Person{ private Date birthDate; public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { Date startDate = Date.valueOf(&quot;1946&quot;); Date endDate = Date.valueOf(&quot;1964&quot;); return birthDate.compareTo(startDate)&gt;=0 &amp;&amp; birthDate.compareTo(endDate) &lt; 0; } }</p>
<p>　　isBornBoomer是用来这个人是否是1946-1964年出生的，而每次isBornBoomer被调用的时候，都会生成startDate和birthDate两个对象，造成了空间浪费，如果改成这样效率会更好，其实就是利用了静态代码块在内存中值加载一次的机制：</p>
<p>class Person{ private Date birthDate; private static Date startDate,endDate; static{ startDate = Date.valueOf(&quot;1946&quot;); endDate = Date.valueOf(&quot;1964&quot;); } public Person(Date birthDate) { this.birthDate = birthDate; } boolean isBornBoomer() { return birthDate.compareTo(startDate)&gt;=0 &amp;&amp; birthDate.compareTo(endDate) &lt; 0; } }</p>
<p>　　因此，很多时候会<strong>将一些只需要进行一次的初始化操作都放在static代码块中进行。</strong></p>
<p><strong>4）静态内部类</strong></p>
<p>这里不单独写静态内部类，通过和普通的内部类对比来加深对静态内部类的理解：</p>
<p>为何要用内部类？</p>
<ol>
<li><p>内部类一般只为其外部类使用；【供外部类使用说的很好 举例 hashmap集合中 有一个内部类 Entry 就是 转为为 hashmap 存储来使用】</p>
</li>
<li><p>内部类提供了某种进入外部类的窗户，内部类存在外部类的引用，所以内部类可以直接访问外部类的属性；</p>
</li>
<li><p>也是最吸引人的原因，每个内部类都能独立地继承一个接口，而无论外部类是否已经继承了某个接口。因此，内部类使多重继承的解决方案变得更加完整。</p>
</li>
</ol>
<p>定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类可以声明public、protected、private等访问限制，可以声明 为abstract的供其他内部类或外部类继承与扩展，或者声明为static、final的，也可以实现特定的接口。</p>
<p>外部类按常规的类访问方式（以对象的方式）使用内部 类，唯一的差别是外部类可以访问内部类的所有方法与属性，包括私有方法与属性，外部类访问内部类，需要创建对象访问；有一点需要注意，内部类不能访问外部类所在的局部变量，只能访问final修饰的局部变量。</p>
<p>举例: 在方法中 定义内部类 然后内部类 调用方法的的入参 则 入参必须是 final 修饰</p>
<p>在方法内定义内部类时，如果内部类调用了方法中的变量，那么该变量必须申明为final类型，百思不得其解，后来想到应该是生命周期的原因，因为方法内定义的变量是局部变量，离开该方法，变量就失去了作用，也就会自动被消除，而内部类却不会离开它所在方法就失去作用，它有更广的生命周期，下面通过一个实例加以说明：</p>
<p>(1)创建实例</p>
<p>OutClass.InnerClass obj = outClassInstance.new InnerClass(); //注意是外部类实例.new，内部类AAA.StaticInner in = new AAA.StaticInner();//注意是外部类本身，静态内部类</p>
<p>(2)内部类中的this</p>
<p>内部类中的this与其他类一样是指的本身。创建内部类对象时，它会与创造它的外围对象有了某种联系，于是能访问外围类的所有成员，不需任何特殊条件，可理解为内部类链接到外部类。 用外部类创建内部类对象时，此内部类对象会秘密的捕获一个指向外部类的引用，于是，可以通过这个引用来访问外围类的成员。</p>
<p>(3)外部类访问内部类</p>
<p>内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。外部类对象通过’外部类名.this.xxx’的形式访问内部类的属性与方法。如：</p>
<p>System.out.println(&quot;Print in inner Outer.index=&quot; + pouter.this.index);</p>
<p>System.out.println(&quot;Print in inner Inner.index=&quot; + this.index);</p>
<p>（4）内部类向上转型</p>
<p>内部类也可以和普通类一样拥有向上转型的特性。将内部类向上转型为基类型，尤其是接口时，内部类就有了用武之地。如果内部类是private的，只可以被它的外部类问，从而完全隐藏实现的细节。</p>
<p>（5）方法内的类</p>
<p>方法内创建的类（注意方法中也能定义类），不能加访问修饰符。另外，方法内部的类也不是在调用方法时才会创建的，它们一样也被事先编译了。</p>
<p>（6）静态内部类</p>
<p>定义静态内部类：在定义内部类的时候，可以在其前面加上一个权限修饰符static。此时这个内部类就变为了静态内部类。</p>
<p>通常称为嵌套类，当内部类是static时，意味着：</p>
<p>[1]要创建嵌套类的对象，并不需要其外围类的对象；</p>
<p>[2]不能从嵌套类的对象中访问非静态的外围类对象（不能够从静态内部类的对象中访问外部类的非静态成员）；</p>
<p>嵌套类与普通的内部类还有一个区别：普通内部类的字段与方法，只能放在类的外部层次上，所以普通的内部类不能有static数据和static字段， 也不能包含嵌套类。但是在嵌套类里可以包含所有这些东西。也就是说，在非静态内部类中不可以声明静态成员，只有将某个内部类修饰为静态类，然后才能够在这 个类中定义静态的成员变量与成员方法。</p>
<p>另外，在创建静态内部类时不需要将静态内部类的实例绑定在外部类的实例上。普通非静态内部类的 对象是依附在外部类对象之中的，要在一个外部类中定义一个静态的内部类，不需要利用关键字new来创建内部类的实例。静态类和方法只属于类本身，并不属于 该类的对象，更不属于其他外部类的对象。</p>
<p>（7）内部类标识符</p>
<p>每个类会产生一个.class文件，文件名即为类名。同样，内部类也会产生这么一个.class文件，但是它的名称却不是内部类的类名，而是有着严格的限制：外围类的名字，加上$,再加上内部类名字。</p>
<p>public class OutClassTest { static int a; int b; public static void test() { System.out.println(&quot;outer class static function&quot;); } public static void main(String[] args) { // new一个外部类 OutClassTest oc1 = new OutClassTest(); // 通过外部类的对象new一个非静态的内部类 OutClassTest.InnerClass no_static_inner = oc1.new InnerClass(); // 调用非静态内部类的方法 System.out.println(no_static_inner.getKey()); // 调用静态内部类的静态变量 System.out.println(OutClassTest.InnerStaticClass.static_value); // 不依赖于外部类实例,直接实例化内部静态类 OutClassTest.InnerStaticClass inner = new OutClassTest.InnerStaticClass(); // 调用静态内部类的非静态方法 System.out.println(inner.getValue()); // 调用内部静态类的静态方法 System.out.println(OutClassTest.InnerStaticClass.getMessage()); } private class InnerClass { // 只有在静态内部类中才能够声明或定义静态成员 // private static String tt = &quot;0&quot;; private int flag = 0; public InnerClass() { // 三.非静态内部类的非静态成员可以访问外部类的非静态变量和静态变量 System.out.println(&quot;InnerClass create a:&quot; + a); System.out.println(&quot;InnerClass create b:&quot; + b); System.out.println(&quot;InnerClass create flag:&quot; + flag); // System.out.println(&quot;InnerClass call outer static function&quot;); // 调用外部类的静态方法 test(); } public String getKey() { return &quot;no-static-inner&quot;; } } private static class InnerStaticClass { // 静态内部类可以有静态成员，而非静态内部类则不能有静态成员。 private static String static_value = &quot;0&quot;; private int flag = 0; public InnerStaticClass() { System.out.println(&quot;InnerClass create a:&quot; + a); // 静态内部类不能够访问外部类的非静态成员 // System.out.println(&quot;InnerClass create b:&quot; + b); System.out.println(&quot;InnerStaticClass flag is &quot; + flag); System.out.println(&quot;InnerStaticClass tt is &quot; + static_value); } public int getValue() { // 静态内部类访问外部类的静态方法 test(); return 1; } public static String getMessage() { return &quot;static-inner&quot;; } } public OutClassTest() { // new一个非静态的内部类 InnerClass ic = new InnerClass(); System.out.println(&quot;OuterClass create&quot;); } }</p>
<p>4）静态导包</p>
<p>静态导包就是java包的静态导入，用import static代替import静态导入包是JDK1.5中的新特性。</p>
<p>一般我们导入一个类都用 import com…..ClassName;而静态导入是这样：import static com…..ClassName.*;这里的多了个static，还有就是类名ClassName后面多了个.* ，<strong>意思是导入这个类里的静态方法</strong>。当然，也可以只导入某个静态方法，只要把 .* 换成静态方法名就行了。然后在这个类中，就可以直接用方法名调用静态方法，而不必用ClassName.方法名 的方式来调用。</p>
<p>好处：这种方法的好处就是可以简化一些操作，例如打印操作System.out.println(…);就可以将其写入一个静态方</p>
<p>法print(…)，在使用时直接print(…)就可以了。但是这种方法建议在有很多重复调用的时候使用，如果仅有一到两次调用，不如直接写来的方便</p>
<p>example:</p>
<p>在Java 5中，import语句得到了增强，以便提供甚至更加强大的减少击键次数功能，虽然一些人争议说这是以可读性为代价的。这种新的特性成为静态导入。当你想使用static成员时，可以使用静态导入（在API中的类和你自己的类上，都可以使用该特性）。下面是静态导入前后的代码实例：</p>
<p>在静态导入之前：</p>
<p>public class TestStatic { public static void main(String[] args) { System.out.println(Integer.MAX_VALUE); System.out.println(Integer.toHexString(42)); } }</p>
<p>在静态导入之后：</p>
<p>import static java.lang.System.out; import static java.lang.Integer.*; public class TestStaticImport { public static void main(String[] args) { out.println(MAX_VALUE); out.println(toHexString(42)); } }</p>
<p>* 让我们看一下使用静态导入特性的代码中将发生什么：</p>
<p>1、虽然该特性通常称为”静态导入”，但语法必须是import static，后面跟你想导入的static成员的完全限定名称，或者通配符。在本例中，我们在System类的out对象上进行静态导入。</p>
<p>2、在本例中，我们可能想使用java.lang.Integer类的几个static成员。该静态导入语句使用通配符来表达”我想在此类中的所有静态成员上进行静态导入”。</p>
<p>3、现在我们终于看到静态导入特性的好处！我们不必在System.out.println中键入System。太好了！另外，我们不必在Integer.MAX_VALUE中键入Integer。因此，在这行代码中，我们能够将快捷方式用于静态方法和一个常量。</p>
<p>4、最后，我们进行更多的快捷操作，这次针对Integer类的方法。</p>
<p>关于该特性，我们已经有点儿讽刺意味儿了，但不仅我们是这样的。我们不认为节省少量的击键次数会让代码难于阅读一点，但许多开发人员要求将它添加到语言中。</p>
<p>下面是使用静态导入的几条原则：</p>
<p>你必须说import static， 不能说static import。</p>
<p>提防含糊不清的命名static成员。例如，如果你对Integer类和Long类执行了静态导入，引用MAX_VALUE将导致一个编译器错误，因为Integer和Long都有一个MAX_VALUE常量，并且Java不会知道你在引用哪个MAX_VALUE。</p>
<p>你可以在static对象引用、常量（记住，它们是static 或final）和static方法上进行静态导入。</p>
<p>二、<strong>单例模式</strong>：软件的运行有且仅有一个实例化对象，也就是只会new一次</p>
<p><strong>构造器是私有的，</strong></p>
<p><strong>只有getInstance()是共有的，且是静态的。</strong></p>
<p>* 懒汉式和饿汉式区别是对象什么时候创建</p>
<p>懒汉式：当第一次调用getInstance()方法时来new对象，之后每次调用该函数都返回之前new好的对象</p>
<p>饿汉式：在类加载之后还没调用时就先new好一个对象，每次（包括第一次）调用该函数都返回之前new好的对象</p>
<p><strong>1. 饿汉模式：</strong></p>
<p>public class Single { // 不能是private static Single private Single() {} private static Single single = new Single(); // 只有用static才可以用类名.方法 public static Single getInstance() { return single;} } public class test1 { public static void main(String[] args) { s1 = new Single(); //报错 Single.single(); //报错 Single s3 = Single.getInstance(); Single s4 = Single.getInstance(); Single s5 = Single.getInstance(); // 这三个都指向同一个实例对象 } }</p>
<ol start="2">
<li>懒汉模式：</li>
</ol>
<p>public class Single { // 不能是private static Single private Single() {} private static Single single = null; public static Single getInstance() { if(single==null) { single = new Single(); return single; }else { return single; } } }</p>
<p><strong>三、静态初始化块 &amp;&amp; 非静态初始化块：</strong></p>
<ol>
<li>初始化块（代码块）作用：对Java对象进行初始化</li>
</ol>
<p><strong>静态初始化块</strong>：使用static定义,当类装载到系统时执行一次.若在静态初始化块中想初始化变量,那仅能初始化类变量,即static修饰的数据成员.</p>
<p><strong>非静态初始化块</strong>：在每个对象生成时都会被执行一次,可以初始化类的实例变量.</p>
<ol start="2">
<li>程序的执行顺序：</li>
</ol>
<p>（1）声明成员变量的默认值，例如下例的String name</p>
<p>（2）显式初始化、多个初始化块依次被执行</p>
<p>（3）构造器再对成员进行赋值操作</p>
<ol start="3">
<li>例如：</li>
</ol>
<p>class Parent { public static String p_StaticField = &quot;父类--静态变量&quot;; public String p_Field = &quot;父类--变量&quot;; //父类的静态初始化块 static { System.out.println(p_StaticField); System.out.println(&quot;父类--静态初始化块&quot;); } //父类的非静态初始化快 { System.out.println(p_Field); System.out.println(&quot;父类--初始化块&quot;); } 　 //父类的构造函数 public Parent() { System.out.println(&quot;父类--构造器&quot;); } } public class SubClass extends Parent { public static String s_StaticField = &quot;子类--静态变量&quot;; public String s_Field = &quot;子类--变量&quot;; // 子类的静态初始化块 static { System.out.println(s_StaticField); System.out.println(&quot;子类--静态初始化块&quot;); } //子类的非静态初始化快 { System.out.println(s_Field); System.out.println(&quot;子类--初始化块&quot;); } 　　　　//子类的构造函数 public SubClass() { System.out.println(&quot;子类--构造器&quot;); } public static void main(String[] args) { new Parent(); System.out.println(&quot;-------------------&quot;); new SubClass(); System.out.println(&quot;-------------------&quot;); new SubClass(); } }</p>
<p><strong>分析：</strong></p>
<p>编译时(运行main之前)按照顺序先加载父类，再加载子类。也就是说先运行父类的静态代码块及静态属性赋值，再运行子类的静态代码块和静态属性赋值</p>
<p>编译完后再运行main方法，new实例时不再运行静态代码块（静态代码块只加载时运行，之后包括new等都不在运行），new实例时只运行非静态代码块</p>
<p>最后再运行构造方法，至此new实例运行结束。</p>
<p>四、final：</p>
<p><strong>类不可被继承，方法不可被重写，属性不可被修改</strong></p>
<ol>
<li>final标记的类不能被继承</li>
</ol>
<p>final标记的方法不能被子类重写</p>
<p>final标记的变量即成为常量，<strong>常量必须显示赋值</strong>，名称大写</p>
<p>2.</p>
<p>public class TestPerson{ int age; final String NAME = &quot;&quot;; // 常量必须显示赋值 // 常量定义名称约定使用大写,多个单词组成则使用_链接 // final在前,static在后 // 一起修饰就是全局常量 final static String NAME_1 =&quot;&quot;; public static void main(String[] args){ final int i=0; // 任何地方都可final } }</p>
<p><strong>五、抽象类：</strong></p>
<p>随着继承层次中一个个新子类的定义，类变得越来越具体，而父类更一般更通用。有的时候将一个父辈设计的非常抽象，以至于它没有具体的实例。</p>
<p>例如：不建立Animal类的实例对象，只建立Dog,Fish,Bird等的实例，Animal类就是抽象类</p>
<ol>
<li>用abstract关键字来修饰一个类时，这个类叫做抽象类。</li>
</ol>
<p>用abstract来修饰一个方法时，该方法叫做抽象方法。</p>
<p>*抽象方法：只有方法的声明没有方法的实现，以分号结束：abstrac int abstracMethod(int a)；</p>
<ol start="2">
<li><p>含有抽象方法的类必须被声明为抽象类</p>
</li>
<li><p>抽象类不能被实例化。抽象类是用来作为父类被继承的，抽象类的子类必须重写抽象类的所有抽象方法，并提供方法体，若没有重写全部的抽象方法，仍为抽象类</p>
</li>
<li><p><strong>不能用abstract修饰属性</strong>，私有方法，构造器，静态方法，final的方法</p>
</li>
</ol>
<p>public abstract class Animal { public abstract void test(); public abstract void eat(); //public abstract int a; //报错，抽象类不能有属性 //这个是允许的，但不可以Animal.b调用，也不能Dog.b，只能dog.b //要想Dog.b调用，只能在Animal类中改为public static int b; public int b; }</p>
<p>编程软件快捷键：先写出下面内容的第一行，点击报错(下面有波浪线)的地方，可以自动重写抽象类的方法：</p>
<p>public class Dog extends Animal{} @Override public void test() { // TODO Auto-generated method stub } @Override public void eat() { System.out.println(&quot;Dog eat!&quot;); } }</p>
<ol start="5">
<li><p>抽象类不能用final关键字声明，前者不能被实例化且子类必须重写父类所有抽象方法并提供方法体，后者不能被继承。</p>
</li>
<li><p>抽象类中可以定义构造器吗？</p>
</li>
</ol>
<p>抽象类中可以有构造方法，只是不能直接创建抽象类的实例对象而已。new Vihicle()是非法的</p>
<p>六、模板设计模式：</p>
<ol>
<li><p>抽象类体现的就是一种模板模式的设计，抽象类作为多个子类的通用模板，子类在抽象类的基础上进行扩展改造，但子类总体上会保留抽象类的行为方式。</p>
</li>
<li><p>解决的问题：</p>
</li>
</ol>
<p>（1）当功能内部一部分实现是确定，一部分实现是不确定的，这时可以把不确定的部分暴露出去，让子类去实现</p>
<p>（2）编写一个抽象父类，父类提供了多个子类的通用方法，并把一个或多个方法留给其子类实现，就是一种模板模式</p>
<ol start="3">
<li><strong>记清下面的例子</strong></li>
</ol>
<p>public abstract class Template{ //计算代码花费的时间 public final void spendTime() { long start = System.currentTimeMillis(); code(); //调用子类重写方法 long end = System.currentTimeMillis(); System.out.println(&quot;程序花费的时间为:&quot;+(end-start)+&quot;毫秒&quot;); } public abstract void code(); } public class TestTmp extends Template{ @Override public void code() { int sum = 0; //前面不能有public for(int i=0; i&lt;100000; i++) { sum += i; } System.out.println(sum); } } public class Test { public static void main(String[] args) { TestTmp t= new TestTmp(); t.spendTime(); } }</p>
<p>七、接口：</p>
<ol>
<li><p>有时必须从几个类中派生出一个子类，继承他们所有的属性和方法。但是Java不支持多重继承。有了接口就可以得到多重继承的效果。</p>
</li>
<li><p>接口是抽象方法和常量值的定义的集合。</p>
</li>
<li><p>从本质上讲，接口是一种特殊的抽象类，这种抽象类中<strong>只包含常量和方法的定义</strong>，而没有常量和方法的实现。</p>
</li>
<li><p>实现接口类：<strong>class SubClass implements InterfaceA{ }</strong></p>
</li>
<li><p>一个类可以实现多个接口，接口也可以继承其它接口</p>
</li>
<li><p>接口的特点：</p>
</li>
</ol>
<p>（1）用interface来定义</p>
<p>（2）接口中的所有成员变量都默认是有public static final修饰的</p>
<p>（3）接口中的所有方法都默认是由public abstract修饰的</p>
<p>（4）接口没有构造器</p>
<p>（5）接口拥有多层继承机制</p>
<ol start="7">
<li>抽象类特点：</li>
</ol>
<p>（1）</p>
<ol start="7">
<li>接口定义举例：</li>
</ol>
<p>public interface Runner{ int id=1; // 等同于public static final int id=1; void start(); // 等同于public abstract void start(); public void run(); // 等同于public abstract void run(); void stop(); // 等同于public abstract void stop(); }</p>
<ol start="8">
<li>包下新建的不是class文件，是interface文件，接口可以继承接口。子类继承父类，只能继承一个父类，类可以实现多个接口，多个接口用逗号分割</li>
</ol>
<p>public class Test1 implements TestIn1, TestIn2{ // implements实现两个事先写好的接口 // 若类没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。 @Override public void test(){ System.out.println(&quot;1&quot;)； //方法内必须有方法体 } @Override public void test(){ System.out.println(&quot;2&quot;)； } }</p>
<ol start="9">
<li><p>实现接口的类中必须提供接口中所有方法的具体事先内容，方可实例化，否则仍为抽象类</p>
</li>
<li><p>接口的主要用途就是被实现类实现（面向接口编程）</p>
</li>
<li><p>与继承关系类似，接口与实现类之间存在多态性</p>
</li>
<li><p>如果一个类既继承父类，又实现接口，则先写extends，后写implements</p>
</li>
<li><p>抽象类增加新的抽象方法子类就会出现问题，这时抽象类不能代替接口的一个因素，有时我们经常需要给父类添加方法。</p>
</li>
</ol>
<p>八、</p>
<ol>
<li><p>抽象方法只能存在于抽象类或者接口中，但抽象类中却能存在非抽象方法，即有方法体的方法。接口是百分之百的抽象类。如果一个类实现了一个接口中要求的所有的方法，然而没有提供方法体而仅仅只有方法标识，那么这个类一定是一个抽象类。</p>
</li>
<li><p>类需要实现接口的所有抽象方法接口的作用就是告诉类，你要实现我这种接口代表的功能，你就必须实现某些方法，我才能承认你确实拥有该接口代表的某种能力。</p>
</li>
<li><p>接口被用来实现抽象，而抽象类也被用来实现抽象，为什么一定要用接口呢？接口和抽象类之间又有什么区别呢？原因是抽象类内部可能包含非final的变量，但是在接口中存在的变量一定是final，public，static的。</p>
</li>
<li><p><strong>接口的属性只能是被final，static，public共同修饰的全局常量</strong></p>
</li>
</ol>
<p>interface in1{ int a=10; //默认被......三个共同修饰 void display(); //默认被abstract，public共同修饰 } class test implements in1{ public void display(){ System.out.println(&quot;1&quot;);//必须有方法体 } } public class XXX{ public static void main(String[] args){ test t=new test(); t.display(); System.out.println(a); //直接输出a即可，不需要写对象.a } }</p>
<p><strong>接口定义的变量怎么调用？</strong></p>
<p>System.out.println(a); //直接输出a，不需要写对象.a</p>
<p>5. 接口的进一步理解：</p>
<p>interface USB { void read(); void write(); }</p>
<p>然后在写一个U盘类和一个键盘类，这两个类都去实现USB接口。（实现其中的方法）</p>
<p>class YouPan implements USB { @Override public void read() { System.out.println(&quot;U盘正在通过USB功能读取数据&quot;); } @Override public void write() { System.out.println(&quot;U盘正在通过USB功能写入数据&quot;); } }</p>
<p>这是U盘的具体实现。</p>
<p>class JianPan implements USB { @Override public void read() { System.out.println(&quot;键盘正在通过USB功能读取数据&quot;); } @Override public void write() { System.out.println(&quot;键盘正在通过USB功能写入数据&quot;); } }</p>
<p>这是键盘的具体实现。那么，现在U盘和键盘都实现了USB功能，也就是说U盘和键盘都能够调用USB接口中规定的方法，并且他们实现的方式都不一样。</p>
<p>我们在写一个测试，来看看具体的实现：</p>
<p>public class Main { public static void main(String[] args) { //生成一个实现可USB接口（标准）的U盘对象 YouPan youPan = new YouPan(); //调用U盘的read( )方法读取数据 youPan.read(); //调用U盘的write( )方法写入数据 youPan.write(); //生成一个实现可USB接口（标准）的键盘对象 JianPan jianPan = new JianPan(); //调用键盘的read( )方法读取数据 jianPan.read(); //调用键盘的write( )方法写入数据 jianPan.write(); } }</p>
<p>* 重点：我们不能直接去实例化一个接口，因为接口中的方法都是抽象的，是没有方法体的，这样怎么可能产生具体的实例呢？但是，我们可以使用接口类型的引用指向一个实现了该接口的对象，并且可以调用这个接口中的方法。因此，上图中最后的方法调用我们还可以这样写：（实际上就是使用了Java中多态的特性）</p>
<p>public class Main { public static void main(String[] args) { //生成一个实现可USB接口（标准）的U盘对象 //但是使用一个接口引用指向对象 //USB接口类引用可以指向一个实现了USB接口的对象 USB youPan = new YouPan(); //调用U盘的read( )方法读取数据 youPan.read(); //调用U盘的write( )方法写入数据 youPan.write(); //生成一个实现可USB接口（标准）的键盘对象 //但是使用一个接口引用指向对象 //USB接口类引用可以指向一个实现了USB接口的对象 USB jianPan = new JianPan(); //调用键盘的read( )方法读取数据 jianPan.read(); //调用键盘的write( )方法写入数据 jianPan.write(); } }</p>
<p>2.一个类可以实现不止一个接口。</p>
<p>3.一个接口可以继承于另一个接口，或者另一些接口，接口也可以继承，并且可以多继承。</p>
<p>4.一个类如果要实现某个接口的话，那么它必须要实现这个接口中的所有方法。</p>
<p>5.接口中所有的方法都是抽象的和public的，所有的属性都是public,static,final共同修饰的。</p>
<p>6.接口用来弥补类无法实现多继承的局限。</p>
<p>7.接口也可以用来实现解耦。</p>
<p>附：</p>
<p>1.Java 接口在JAVA编程语言中是一个抽象类型，是抽象方法的集合，接口通常以interface来声明。一个类通过继承接口的方式，从而来继承接口的抽象方法。</p>
<p>2.接口并不是类，编写接口的方式和类很相似，但是它们属于不同的概念。类描述对象的属性和方法。接口则包含类要实现的方法。</p>
<p>3.除非实现接口的类是抽象类，否则该类要定义接口中的所有方法。</p>
<p>4.接口无法被实例化，但是可以被实现。一个实现接口的类，必须实现接口内所描述的所有方法，否则就必须声明为抽象类。另外，在 Java 中，接口类型可用来声明一个变量，他们可以成为一个空指针，或是被绑定在一个以此接口实现的对象。</p>
<p><strong>5.接口与类相似点：</strong></p>
<p>一个接口可以有多个方法。</p>
<p>接口文件保存在 .java 结尾的文件中，文件名使用接口名。</p>
<p>接口的字节码文件保存在 .class 结尾的文件中。</p>
<p>接口相应的字节码文件必须在与包名称相匹配的目录结构中。</p>
<p>接口与类的区别：</p>
<p>接口不能用于实例化对象。</p>
<p>接口没有构造方法。</p>
<p>接口中所有的方法必须是抽象方法。</p>
<p>接口不能包含成员变量，除了 static 和 final 变量。</p>
<p>接口不是被类继承了，而是要被类实现。</p>
<p>接口支持多继承。</p>
<p>6.接口特性：</p>
<p>接口中每一个方法也是隐式抽象的,接口中的方法会被隐式的指定为 public abstract（只能是 public abstract，其他修饰符都会报错）。</p>
<p>接口中可以含有变量，但是接口中的变量会被隐式的指定为 public static final 变量（并且只能是 public，用 private 修饰会报编译错误）。</p>
<p>接口中的方法是不能在接口中实现的，只能由实现接口的类来实现接口中的方法。</p>
<p><strong>7.抽象类和接口的区别</strong></p>
<p>抽象类中的方法可以有方法体，就是能实现方法的具体功能，但是接口中的方法不行。</p>
<p>抽象类中的成员变量可以是各种类型的，而接口中的成员变量只能是 public static final 类型的。</p>
<p>接口中不能含有静态代码块以及静态方法(用 static 修饰的方法)，而抽象类是可以有静态代码块和静态方法。</p>
<p>一个类只能继承一个抽象类，而一个类却可以实现多个接口。</p>
<p>注：JDK 1.8 以后，接口里可以有静态方法和方法体了。</p>
<p><strong>8. 抽象类很简单</strong></p>
<p>要求只有：抽象类不能被实例化，抽象类的子类必须重写抽象类的所有抽象方法，并提供方法体，不能用abstract修饰属性，私有方法，构造器，静态方法，final的方法</p>
 
      <!-- reward -->
      
      <div id="reword-out">
        <div id="reward-btn">
          Donate
        </div>
      </div>
      
    </div>
    

    <!-- copyright -->
    
    <div class="declare">
      <ul class="post-copyright">
        <li>
          <i class="ri-copyright-line"></i>
          <strong>Copyright： </strong>
          
          Copyright is owned by the author. For commercial reprints, please contact the author for authorization. For non-commercial reprints, please indicate the source.
          
        </li>
      </ul>
    </div>
    
    <footer class="article-footer">
       
<div class="share-btn">
      <span class="share-sns share-outer">
        <i class="ri-share-forward-line"></i>
        分享
      </span>
      <div class="share-wrap">
        <i class="arrow"></i>
        <div class="share-icons">
          
          <a class="weibo share-sns" href="javascript:;" data-type="weibo">
            <i class="ri-weibo-fill"></i>
          </a>
          <a class="weixin share-sns wxFab" href="javascript:;" data-type="weixin">
            <i class="ri-wechat-fill"></i>
          </a>
          <a class="qq share-sns" href="javascript:;" data-type="qq">
            <i class="ri-qq-fill"></i>
          </a>
          <a class="douban share-sns" href="javascript:;" data-type="douban">
            <i class="ri-douban-line"></i>
          </a>
          <!-- <a class="qzone share-sns" href="javascript:;" data-type="qzone">
            <i class="icon icon-qzone"></i>
          </a> -->
          
          <a class="facebook share-sns" href="javascript:;" data-type="facebook">
            <i class="ri-facebook-circle-fill"></i>
          </a>
          <a class="twitter share-sns" href="javascript:;" data-type="twitter">
            <i class="ri-twitter-fill"></i>
          </a>
          <a class="google share-sns" href="javascript:;" data-type="google">
            <i class="ri-google-fill"></i>
          </a>
        </div>
      </div>
</div>

<div class="wx-share-modal">
    <a class="modal-close" href="javascript:;"><i class="ri-close-circle-line"></i></a>
    <p>扫一扫，分享到微信</p>
    <div class="wx-qrcode">
      <img src="//api.qrserver.com/v1/create-qr-code/?size=150x150&data=https://gitee.com/zhang-shuo-fr/hexo1.git/2019/08/13/java%E5%9F%BA%E7%A1%80/%E7%AC%94%E8%AE%B01/" alt="微信分享二维码">
    </div>
</div>

<div id="share-mask"></div>  
  <ul class="article-tag-list" itemprop="keywords"><li class="article-tag-list-item"><a class="article-tag-list-link" href="/hexo1/tags/%E5%88%9D%E5%AD%A6java/" rel="tag">初学java</a></li></ul>

    </footer>
  </div>

   
  <nav class="article-nav">
    
      <a href="/hexo1/2019/08/13/java%E5%9F%BA%E7%A1%80/%E9%9A%8F%E7%AC%94/" class="article-nav-link">
        <strong class="article-nav-caption">上一篇</strong>
        <div class="article-nav-title">
          
            java基础随笔1
          
        </div>
      </a>
    
    
  </nav>

   
<!-- valine评论 -->
<div id="vcomments-box">
  <div id="vcomments"></div>
</div>
<script src="//cdn1.lncld.net/static/js/3.0.4/av-min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/valine@1.4.14/dist/Valine.min.js"></script>
<script>
  new Valine({
    el: "#vcomments",
    app_id: "",
    app_key: "",
    path: window.location.pathname,
    avatar: "monsterid",
    placeholder: "给我的文章加点评论吧~",
    recordIP: true,
  });
  const infoEle = document.querySelector("#vcomments .info");
  if (infoEle && infoEle.childNodes && infoEle.childNodes.length > 0) {
    infoEle.childNodes.forEach(function (item) {
      item.parentNode.removeChild(item);
    });
  }
</script>
<style>
  #vcomments-box {
    padding: 5px 30px;
  }

  @media screen and (max-width: 800px) {
    #vcomments-box {
      padding: 5px 0px;
    }
  }

  #vcomments-box #vcomments {
    background-color: #fff;
  }

  .v .vlist .vcard .vh {
    padding-right: 20px;
  }

  .v .vlist .vcard {
    padding-left: 10px;
  }
</style>

 
   
     
</article>

</section>
      <footer class="footer">
  <div class="outer">
    <ul>
      <li>
        Copyrights &copy;
        2020-2021
        <i class="ri-heart-fill heart_icon"></i> Zhang Shuo
      </li>
    </ul>
    <ul>
      <li>
        
      </li>
    </ul>
    <ul>
      <li>
        
        
        <span>
  <span><i class="ri-user-3-fill"></i>Visitors:<span id="busuanzi_value_site_uv"></span></span>
  <span class="division">|</span>
  <span><i class="ri-eye-fill"></i>Views:<span id="busuanzi_value_page_pv"></span></span>
</span>
        
      </li>
    </ul>
    <ul>
      
    </ul>
    <ul>
      
    </ul>
    <ul>
      <li>
        <!-- cnzz统计 -->
        
        <script type="text/javascript" src=''></script>
        
      </li>
    </ul>
  </div>
</footer>    
    </main>
    <div class="float_btns">
      <div class="totop" id="totop">
  <i class="ri-arrow-up-line"></i>
</div>

<div class="todark" id="todark">
  <i class="ri-moon-line"></i>
</div>

    </div>
    <aside class="sidebar on">
      <button class="navbar-toggle"></button>
<nav class="navbar">
  
  <div class="logo">
    <a href="/hexo1/"><img src="/hexo1/images/ayer-side.svg" alt="Zhang Shuo&#39;s Studio"></a>
  </div>
  
  <ul class="nav nav-main">
    
    <li class="nav-item">
      <a class="nav-item-link" href="/hexo1/">主页</a>
    </li>
    
    <li class="nav-item">
      <a class="nav-item-link" href="/hexo1/archives">归档</a>
    </li>
    
    <li class="nav-item">
      <a class="nav-item-link" href="/hexo1/categories">分类</a>
    </li>
    
    <li class="nav-item">
      <a class="nav-item-link" href="/hexo1/tags">标签</a>
    </li>
    
    <li class="nav-item">
      <a class="nav-item-link" href="/hexo1/tags/%E6%97%85%E8%A1%8C/">旅行</a>
    </li>
    
    <li class="nav-item">
      <a class="nav-item-link" target="_blank" rel="noopener" href="http://shenyu-vip.lofter.com">摄影</a>
    </li>
    
    <li class="nav-item">
      <a class="nav-item-link" href="/hexo1/2019/about">关于我</a>
    </li>
    
  </ul>
</nav>
<nav class="navbar navbar-bottom">
  <ul class="nav">
    <li class="nav-item">
      
      <a class="nav-item-link nav-item-search"  title="Search">
        <i class="ri-search-line"></i>
      </a>
      
      
      <a class="nav-item-link" target="_blank" href="/hexo1/atom.xml" title="RSS Feed">
        <i class="ri-rss-line"></i>
      </a>
      
    </li>
  </ul>
</nav>
<div class="search-form-wrap">
  <div class="local-search local-search-plugin">
  <input type="search" id="local-search-input" class="local-search-input" placeholder="Search...">
  <div id="local-search-result" class="local-search-result"></div>
</div>
</div>
    </aside>
    <div id="mask"></div>

<!-- #reward -->
<div id="reward">
  <span class="close"><i class="ri-close-line"></i></span>
  <p class="reward-p"><i class="ri-cup-line"></i>请我喝杯咖啡吧~</p>
  <div class="reward-box">
    
    <div class="reward-item">
      <img class="reward-img" src="/hexo1/images/alipay.jpg">
      <span class="reward-type">支付宝</span>
    </div>
    
    
    <div class="reward-item">
      <img class="reward-img" src="/hexo1/images/wechat.jpg">
      <span class="reward-type">微信</span>
    </div>
    
  </div>
</div>
    
<script src="/hexo1/js/jquery-3.6.0.min.js"></script>
 
<script src="/hexo1/js/lazyload.min.js"></script>

<!-- Tocbot -->
 
<script src="/hexo1/js/tocbot.min.js"></script>

<script>
  tocbot.init({
    tocSelector: ".tocbot",
    contentSelector: ".article-entry",
    headingSelector: "h1, h2, h3, h4, h5, h6",
    hasInnerContainers: true,
    scrollSmooth: true,
    scrollContainer: "main",
    positionFixedSelector: ".tocbot",
    positionFixedClass: "is-position-fixed",
    fixedSidebarOffset: "auto",
  });
</script>

<script src="https://cdn.jsdelivr.net/npm/jquery-modal@0.9.2/jquery.modal.min.js"></script>
<link
  rel="stylesheet"
  href="https://cdn.jsdelivr.net/npm/jquery-modal@0.9.2/jquery.modal.min.css"
/>
<script src="https://cdn.jsdelivr.net/npm/justifiedGallery@3.7.0/dist/js/jquery.justifiedGallery.min.js"></script>

<script src="/hexo1/dist/main.js"></script>

<!-- ImageViewer -->
 <!-- Root element of PhotoSwipe. Must have class pswp. -->
<div class="pswp" tabindex="-1" role="dialog" aria-hidden="true">

    <!-- Background of PhotoSwipe. 
         It's a separate element as animating opacity is faster than rgba(). -->
    <div class="pswp__bg"></div>

    <!-- Slides wrapper with overflow:hidden. -->
    <div class="pswp__scroll-wrap">

        <!-- Container that holds slides. 
            PhotoSwipe keeps only 3 of them in the DOM to save memory.
            Don't modify these 3 pswp__item elements, data is added later on. -->
        <div class="pswp__container">
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
            <div class="pswp__item"></div>
        </div>

        <!-- Default (PhotoSwipeUI_Default) interface on top of sliding area. Can be changed. -->
        <div class="pswp__ui pswp__ui--hidden">

            <div class="pswp__top-bar">

                <!--  Controls are self-explanatory. Order can be changed. -->

                <div class="pswp__counter"></div>

                <button class="pswp__button pswp__button--close" title="Close (Esc)"></button>

                <button class="pswp__button pswp__button--share" style="display:none" title="Share"></button>

                <button class="pswp__button pswp__button--fs" title="Toggle fullscreen"></button>

                <button class="pswp__button pswp__button--zoom" title="Zoom in/out"></button>

                <!-- Preloader demo http://codepen.io/dimsemenov/pen/yyBWoR -->
                <!-- element will get class pswp__preloader--active when preloader is running -->
                <div class="pswp__preloader">
                    <div class="pswp__preloader__icn">
                        <div class="pswp__preloader__cut">
                            <div class="pswp__preloader__donut"></div>
                        </div>
                    </div>
                </div>
            </div>

            <div class="pswp__share-modal pswp__share-modal--hidden pswp__single-tap">
                <div class="pswp__share-tooltip"></div>
            </div>

            <button class="pswp__button pswp__button--arrow--left" title="Previous (arrow left)">
            </button>

            <button class="pswp__button pswp__button--arrow--right" title="Next (arrow right)">
            </button>

            <div class="pswp__caption">
                <div class="pswp__caption__center"></div>
            </div>

        </div>

    </div>

</div>

<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/photoswipe.min.css">
<link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/default-skin/default-skin.min.css">
<script src="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/photoswipe.min.js"></script>
<script src="https://cdn.jsdelivr.net/npm/photoswipe@4.1.3/dist/photoswipe-ui-default.min.js"></script>

<script>
    function viewer_init() {
        let pswpElement = document.querySelectorAll('.pswp')[0];
        let $imgArr = document.querySelectorAll(('.article-entry img:not(.reward-img)'))

        $imgArr.forEach(($em, i) => {
            $em.onclick = () => {
                // slider展开状态
                // todo: 这样不好，后面改成状态
                if (document.querySelector('.left-col.show')) return
                let items = []
                $imgArr.forEach(($em2, i2) => {
                    let img = $em2.getAttribute('data-idx', i2)
                    let src = $em2.getAttribute('data-target') || $em2.getAttribute('src')
                    let title = $em2.getAttribute('alt')
                    // 获得原图尺寸
                    const image = new Image()
                    image.src = src
                    items.push({
                        src: src,
                        w: image.width || $em2.width,
                        h: image.height || $em2.height,
                        title: title
                    })
                })
                var gallery = new PhotoSwipe(pswpElement, PhotoSwipeUI_Default, items, {
                    index: parseInt(i)
                });
                gallery.init()
            }
        })
    }
    viewer_init()
</script> 
<!-- MathJax -->

<!-- Katex -->

<!-- busuanzi  -->
 
<script src="/hexo1/js/busuanzi-2.3.pure.min.js"></script>
 
<!-- ClickLove -->

<!-- ClickBoom1 -->

<!-- ClickBoom2 -->

<!-- CodeCopy -->
 
<link rel="stylesheet" href="/hexo1/css/clipboard.css">
 <script src="https://cdn.jsdelivr.net/npm/clipboard@2/dist/clipboard.min.js"></script>
<script>
  function wait(callback, seconds) {
    var timelag = null;
    timelag = window.setTimeout(callback, seconds);
  }
  !function (e, t, a) {
    var initCopyCode = function(){
      var copyHtml = '';
      copyHtml += '<button class="btn-copy" data-clipboard-snippet="">';
      copyHtml += '<i class="ri-file-copy-2-line"></i><span>COPY</span>';
      copyHtml += '</button>';
      $(".highlight .code pre").before(copyHtml);
      $(".article pre code").before(copyHtml);
      var clipboard = new ClipboardJS('.btn-copy', {
        target: function(trigger) {
          return trigger.nextElementSibling;
        }
      });
      clipboard.on('success', function(e) {
        let $btn = $(e.trigger);
        $btn.addClass('copied');
        let $icon = $($btn.find('i'));
        $icon.removeClass('ri-file-copy-2-line');
        $icon.addClass('ri-checkbox-circle-line');
        let $span = $($btn.find('span'));
        $span[0].innerText = 'COPIED';
        
        wait(function () { // 等待两秒钟后恢复
          $icon.removeClass('ri-checkbox-circle-line');
          $icon.addClass('ri-file-copy-2-line');
          $span[0].innerText = 'COPY';
        }, 2000);
      });
      clipboard.on('error', function(e) {
        e.clearSelection();
        let $btn = $(e.trigger);
        $btn.addClass('copy-failed');
        let $icon = $($btn.find('i'));
        $icon.removeClass('ri-file-copy-2-line');
        $icon.addClass('ri-time-line');
        let $span = $($btn.find('span'));
        $span[0].innerText = 'COPY FAILED';
        
        wait(function () { // 等待两秒钟后恢复
          $icon.removeClass('ri-time-line');
          $icon.addClass('ri-file-copy-2-line');
          $span[0].innerText = 'COPY';
        }, 2000);
      });
    }
    initCopyCode();
  }(window, document);
</script>
 
<!-- CanvasBackground -->

<script>
  if (window.mermaid) {
    mermaid.initialize({ theme: "forest" });
  }
</script>


    
    <div id="music">
    
    
    
    <iframe frameborder="no" border="1" marginwidth="0" marginheight="0" width="200" height="52"
        src="//music.163.com/outchain/player?type=2&id=22707008&auto=1&height=32"></iframe>
</div>

<style>
    #music {
        position: fixed;
        right: 15px;
        bottom: 0;
        z-index: 998;
    }
</style>
    
    

  </div>
</body>

</html>